perf: skip receiver registration for ordinary objects - #6790

BenchmarkDotNet.Running.BenchmarkSwitcher.FromAssembly(typeof(ReceiverBench).Assembly).Run(args);

using System.Linq.Expressions;
using System.Reflection;
using System.Runtime.Loader;
using BenchmarkDotNet.Attributes;
using TUnit.Core;
using TUnit.Core.Interfaces;

[MemoryDiagnoser]
public class ReceiverBench
{
    [Params(false, true)]
    public bool WithReceivers { get; set; }
    private TestContext[] _contexts = null!;
    private object[] _instances = null!;
    private Func<object> _beforeFactory = null!, _afterFactory = null!;
    private Action<object, TestContext> _beforeRegister = null!, _afterRegister = null!;
    private Action<object, TestContext> _beforeClass = null!, _afterClass = null!;

    [GlobalSetup]
    public void Setup()
    {
        var root = Environment.GetEnvironmentVariable("PERF_ROOT") ?? "C:/git/TUnit-perf-evidence-20260912";
        (_beforeFactory, _beforeRegister, _beforeClass) = Load(root + "/baseline-runner/TUnit.Engine.dll");
        (_afterFactory, _afterRegister, _afterClass) = Load(root + "/idea3-runner/TUnit.Engine.dll");
        _instances = Enumerable.Range(0, 1000).Select(_ => WithReceivers ? (object)new Receiver() : new object()).ToArray();
        _contexts = Enumerable.Range(0, 1000).Select(i =>
        {
            var context = new TestContext("Test", null!, null!, new TestBuilderContext { TestMetadata = null! }, CancellationToken.None);
            context.Metadata.TestDetails = new TestDetails([new TestAttribute()])
            {
                TestId = i.ToString(), TestName = "Test", ClassType = typeof(ReceiverBench), MethodName = "Test",
                ClassInstance = null!, TestMethodArguments = [], TestClassArguments = [], MethodMetadata = null!,
                ReturnType = typeof(void), AttributesByType = new Dictionary<Type, IReadOnlyList<Attribute>>()
            };
            return context;
        }).ToArray();
        Validate(Before());
        Validate(After());
    }

    private void Validate(object orchestrator)
    {
        var registry = orchestrator.GetType().GetField("_registry", BindingFlags.Instance | BindingFlags.NonPublic)!.GetValue(orchestrator)!;
        var hasReceivers = (bool)registry.GetType().GetMethod("HasTestStartReceivers")!.Invoke(registry, null)!;
        if (hasReceivers != WithReceivers) throw new Exception("Incorrect receiver registration");
    }

    [GlobalCleanup]
    public void Cleanup()
    {
        foreach (var context in _contexts) { context.RemoveFromRegistry(); context.Dispose(); }
    }

    [Benchmark(Baseline = true)]
    public object Before() => Register(_beforeFactory, _beforeRegister, _beforeClass);
    [Benchmark]
    public object After() => Register(_afterFactory, _afterRegister, _afterClass);

    private object Register(Func<object> factory, Action<object, TestContext> register, Action<object, TestContext> registerClass)
    {
        var orchestrator = factory();
        // One operation registers a 1,000-test suite in a fresh session. The loop is
        // the actual workload, not artificial repetition of a single warmed registration.
        for (var i = 0; i < _contexts.Length; i++)
        {
            var context = _contexts[i];
            context.Metadata.TestDetails.ClassInstance = null!;
            context.InvalidateEventReceiverCaches();
            register(orchestrator, context);
            context.Metadata.TestDetails.ClassInstance = _instances[i];
            registerClass(orchestrator, context);
        }
        return orchestrator;
    }

    private static (Func<object>, Action<object, TestContext>, Action<object, TestContext>) Load(string path)
    {
        var loadContext = new AssemblyLoadContext(path, isCollectible: true);
        var type = loadContext.LoadFromAssemblyPath(Path.GetFullPath(path)).GetType("TUnit.Engine.Services.EventReceiverOrchestrator", true)!;
        var constructor = type.GetConstructors().Single();
        var factory = Expression.Lambda<Func<object>>(Expression.Convert(
            Expression.New(constructor, Expression.Constant(null, constructor.GetParameters()[0].ParameterType)), typeof(object))).Compile();
        return (factory, Bind("RegisterReceivers"), Bind("RegisterClassInstanceReceiver"));

        Action<object, TestContext> Bind(string name)
        {
            var instance = Expression.Parameter(typeof(object));
            var context = Expression.Parameter(typeof(TestContext));
            return Expression.Lambda<Action<object, TestContext>>(Expression.Call(
                Expression.Convert(instance, type), type.GetMethod(name)!, context), instance, context).Compile();
        }
    }

    public class Receiver : ITestStartEventReceiver
    {
        public ValueTask OnTestStart(TestContext context) => ValueTask.CompletedTask;
    }
}